תוכן עניינים I בעיות מיון 2 1 סימון אסימפטוטי... 2 II מבני נתונים 20 8 מבני נתונים מופשטים משפט האב גרפים... 37

תוכן עניינים I בעיות מיון 2 1 סימון אסימפטוטי................................................ 2 2 מיון בועות. Bubble Sort............................................ 2 3 מיון מיזוג. Merge Sort............................................ 5 4 מיון מנייה. Counting sort........................................... 9 5 מיון ראדיקס. Radix sort........................................... 11 6 מיון מהיר. Quick sort............................................. 11 7 משפט האב.................................................... 13 II מבני נתונים 20 8 מבני נתונים מופשטים............................................... 21 9 עצי חיפוש בינאריים Trees. BST (Binary Search.............................. 30 10 עצי (Adelson-Velskii Landis AVL...................................... 34 11 גרפים....................................................... 37 12 עצים פורשים מינימלית בגרף Tree. MST (Minimum Spanning...................... 47 13 אלגוריתם קידוד המידע (דחיסת המידע של הופמן. Human........................ 57 1

חלק I בעיות מיון 1 סימון אסימפטוטי הגדרה "O" 1.1 ( Oגדול נגדיר (n f (n = O (g אם קיימים קבועים,O < n 0, c כך ש (n f (n c g לכל.n > n 0 הגדרה "Ω" 1.2 נגדיר (n f (n = Ω (g אם קיימים < n 0, c 0 כך ש: (n f (n c g לכל.n > n 0 "Θ" הגדרה 1.3 נגדיר (n, f (n = Θ (g אם (n f (n = O (g וגם (n f (n = Ω (g עבור קבועים < c 1, c 2, n 0 0 כך ש:.n 0 N עבור כל,c 1 g (n f (n c 2 g (n הגדרה o"o" 1.4 קטן.g זניח ביחס ל( n f (n כלומר, lim f (n נגדיר: (n f (n = o (g אם = 0 (n n g 2 מיון בועות Bubble Sort השיטה הפשוטה ביותר למיון מערך. Pseudo code : f o r i =1 to i = n 1 f o r j = 1 to n i do i f A[ j ] >= A[ j +1] then swap A[ j ] and [ j +1] הסבר: השיטה רצה על כל המערך, ומשווה בין כל זוג תאים. 2.1 הוכחת נכונות נוכיח באינדוקציה על k את הטענה הבאה: טענה 2.1 לאחר k איטרצות של הלולאה החיצונית, k המספרים הגדולים (כלומר התאים האחרונים במערך במערך נמצאים במקומם הנכון. נשים לב כי הוכחת הטענה מוכיחה עבור מערך שלם בגודל n, כי עבור מערך בגודל n, לאחר 1 n פעולות המערך ממוין. בסיס האינדוקציה: n. לאחר איטרציה אחת של הלולאה החיצונית, המספר הגדול ביותר מגיע למקום ה k. = 1 2

עבור = 1 i בלולאה הפנימית j רץ מתא 1 עד 1 n, ולכן משווה כל שני תאים סמוכים עבור המערך השלם. נניח שקיים ערך מקסימלי max באינדקס m, כאשר j, = m תתקיים החלפה בין אינדקס m לאינדקס + 1 m. מכיוון ש max הוא הערך המקסימלי במערך, כל עוד j n i תתבצע החלפה עם האיבר אחריו. אולם = 1 i, ולכן ערכו המקסימלי j הוא 1 n j = (נזכור כי 1 n הוא התא האחרון במערך. מעבר האינדוקציה: נניח נכונות הטענה עבור kונוכיח עבור + 1 k. לפי הנחת האינדוקציה, k התאים האחרונים כבר ממוינים, כי עבור האיטרציה ה k+1 של הלולאה החיצונית, האיבר ה 1+k בגודלו במערך יגיע למקומו הנכון בתנאי שהוא k].a [n עבור +1 k,i = המשתנה הפנימי רץ מ 1 ל 1 k (n (k + 1 = (n ומבצע החלפה אם צריך. כמו בשלב = 1 k, המספר המקסימלי במערך החלקי (כלומר: {[1 k A} [1] A... n] יגיע לתא האחרון במערך זה, שהוא: [1 k A.מש"ל. n] 2.2 ניתוח זמן ריצה הפעולות המתבצעות: 1. השוואת זוג תאים סמוכים. (1 Θ. 2. החלפה בין זוג תאים סמוכים. (1 Θ. 3. קידום המשתנה האיטרציה. (1 Θ. 2.3 זמן ריצה n 1 n 1 T (n = 1 + (1 + 1 + 1 = (n 1 + i=1 j=1 n 1 3 (n i i=1 = m (n 1 + 3 (1 + 2 +... + (n 1 n (n 1 = (n 1 + 3 = 3 2 2 n2 1 2 n 1 המשוואה לעיל אינה מתארת במדויק את תהליך המיון, מכיוון שלא בכל שלב באיטרציה מתבצע החלפה בין שני תאים. ישנם שני דיוקים אפשריים: 1. לשנות את השוויון (=ל"קטן או שווה" (. כלומר:... (n T. 2. להגדיר את המשוואה כתיאור עבור המקרה הגרוע ביותר (שהוא, כאשר המערך מסודר בסדר הפוך. משוואת זמן הריצה אינה תלויה בקבועים שבה, אלא בגודל המערך n. נניח כי "עלות" הפעולות משתנה: 3

n 1 n 1 T (n = z + (x + y + z =... = (x + y + z i=1 j=1 n (n 1 2 = 1. השוואת זוג תאים סמוכים. (x Θ. 2. החלפה בין זוג תאים סמוכים. (y Θ. 3. קידום המשתנה האיטרציה. (z Θ. (x + y + z n 2 2 אזי פיתוח המשוואה ייראה כך: (x + y + z n 2 התלות הריבועית ב n אינו משתנה. בצורה רקורסיבית 2.4 BubbleSort BubbleSort A [1,..., n] if ( n =1 return (1 else Bubble A [1,..., n] BubbleSort A [1,...,n -1] מתודת העזר: Bubble A [1,..., k] for j =1 to k -1 if A[j] > A[j +1] and A[j +1] 2.4.1 זמן ריצה רקורסיה n. על קלט בגודל BubbleSort זמן ריצה של T (n k. על קלט בגודל Bubble זמן ריצה של S (n משוואה רקורסיבית עבור > 1 n T (n, T (n = T (n 1 + S (n T (1 = Θ (1 S (k = Θ (k 4

טענה 2 2.2 T (n = Θ ( n לכל 1,k.c 1 k S (k c 2 k הוכחה: קיימים קבועים c 1 < c 2 חיוביים כך שלכל > 1 :n T (n 1 + c 1 n T (n T (n 1 + c 2 n T (1 = δ נסמן: d}.m = max {c 2, d}, m = min {c 1, נוכיח כי לכל > 1 nמתקיים:,m n 2 T (n M n 2 ולכן: 2.T (n = Θ ( n את המשוואה: m n 2 T (n M n 2 נוכיח באינדוקציה על :n בסיס: T (1 = d max (c 2, d = M מעבר: נכתוב את הטענה לn, ונוכיח עבור + 1 n: T (n + 1 T (n + c 2 (n + 1 M n 2 + M (n + 1 = M ( n 2 + n + 1 < M ( n 2 + 2n + 1 = M (n + 1 2 T (n T (n 1 + c 2 n. T (2 T (1 + c 2 2 T (n T (1 c 2 (2 + 3 +... + n = c 2 ( n (n + 1 2 1 = Θ ( n 2 נחסיר טורים: 3 מיון מיזוג Merge Sort MergeSort A[ 1,..., n ] i f n=1 return 1 e l s e MergeSort (A[ 1,..., n / 2 ] MergeSort (A[ ( n / 2 + 1,..., n ] Merge (A [ 1,..., n / 2 ], A[ ( n / 2 + 1,..., n, A[ 1,..., n ] 5

Merge (B [ 1,..., k ], C [ 1,...,m], A[ 1,..., k+m] A_pointer = 1 B_pointer=1 C_pointer=1 while ( A_pointer<k+m+1 w h i l e (B[ B_pointer]<C[ C_pointer ] OR C_pointer=m+1 AND B_pointer<k+1 A[ A_pointer]=B[ B_pointer ] A_pointer++ B_pointer++ w h i l e (C[ C_pointer]<B[ B_pointer ] OR B_pointer=k+1 AND C_pointer<m+1 A[ A_pointer]=C[ C_pointer ] A_pointer++ C_pointer++ זמן ריצה 3.1 Merge נניח ששתי המערכים ([m,1]b,...,[k C,1],.. ממוינים, נשווה בין שתי תאים במערך, ונכניס את הערך הקטן מבינהם במערך.A זמן ריצה: m.θ (k + 3.2 ניתוח אלגוריתם 3.2.1 נכונות :Merge בכל השוואה בין Bל Cמכניסים איבר ל Aבאופן ממוין. n 2 ממוינים, ואז ממזגים אותם. :MergeSort מניחים שמערכיו באורך T (n = 2 T ( n 2 + Θ (n 3.2.2 זמן ריצה m. זמן ריצה של מיון ממוזג על קלט באורך T (m.merge זמן הריצה של Θ (n T (1 = Θ (1 הפונקציה T חסומה, כי היא חסומה מלמעלה ומלמטה על ידי קבוע. טענה logn 3.1 T (n = Θ (n 6

2T ( n 2 + d 1 n T (n 2T הוכחה: באופן מפורש, המשוואה הרקורסיבית היא: ( n + d 2 n 2 d 1 T (1 d 2 נוכיח באינדוקציה כי T (n = Θ (n log (n d 1 nlog 2 n + d 1 n T (n d 2 n log 2 n + d 2 n.t (n d 2 n log 2 (n + d 2 n נוכיח באינדוקציה על kכי,n = 2 k מקרה בסיס: = 0 1 k.t (1 d 2 d 2 1 log 2 (1 + d 2 1,n = מעבר: נניח נכונות עבור.2 k = n :k ונוכיח עבור + 1 k.2 k+1 = 2n : T (2n 2T (n + d 2 (2n 2 (d 2 n log 2 (n + d 2 n + d 2 (2n = 2 d 2 n log 2 (2n + d 2 (2n הרעיון של פתרון בעיה אלגוריתמית על ידי חלוקתה לבעיות קטנות יותר ומיזוג הפתרונות החלקים לפתרון הבעיה הגדולה נקרא, n b כאשר הפרד ומשול Conquer.(Divide & דוגמא חשובה לרעיון זה נלמד בקורס לאלגוריתמים אלגוריתמים דינמיים. הכללה של הבעיה הרקורסיבית: נתונה בעיה בגודל n ואלגוריתם הפותר אותה על ידי חלוקתה ל a בעיות בגודל מחיר המיזוג של הפתרונות החלקיים לפתרון הבעיה המקורית הוא (k, n,b (k Θ, ( n הינם פרמטרים של הבעיה. ( n T (n = a T + Θ ( n k b הבעיה הרקורסיבית: T (1 = Θ (1 T (n =? T (n = C n k + C a ( ( n k ( b + C a 2 n k ( b + C a r 1 n k 2 b = C r 1 nk 1 + a + a2 +... + ar 1 = b k (b 2 ( k (b r 1 k C n k 1 + a + ( a 2 ( b k b +... + a r 1 k b k 3.3 שיטת האיטרציה 3.3.1 ניתוח איטרטיבי עבור BubbleSort נוסחת נסיגה: T (n = T (n 1 + Θ (n T (n = T (n 1 + c n T (n 1 = T (n 2 + c (n 1 7

איור 1: עץ רקורסיה נציב את משוואה 3.2 במשוואה 3.1: T (n = T (n 2 + c (n 1 + c n עבור מקרה כללי: i 1 T (n = T (n i + (n k k=0 n 2 (n 1 (n + 2 T (n = T (1 + (n k d + c 2 k=0 T (n = Θ ( n 2 עבור מקרה אחרון: זמן הריצה הוא: 3.3.2 ניתוח איטרטיבי עבור MergeSort T (n = 2 T ( n 2 + c n נוסחת נסיגה: ( n T = 2 T 2 8 ( n 4 + c n 2

( ( n T (n = 2 2 T 4 + c n + c n 2 2T 2 T (n = 2 2 T ( n 2 2 + 2cn על ידי הצבת משוואה 3.4 במשוואה 3.3, נקבל: ( n + c n + c n 4 T (n = 2 k T ( n 2 k + k cn עבור k פעמים, נקבל: T (n = 2 log2n T (1 + log 2 n cn n d + cn log 2 n T (n = Θ (n log (n.t ( n 2 k = T ( n n עבור = T (1 :n = 2 k :T (1 = const. = d,k = log 2 n n = 2 k זמן הריצה הוא: 4 מיון מנייה Counting sort ידע מוקדם: כל איבר במערך הוא מספר שלם בטווח {k,...,1}. הרעיון: ˆ אין צורך להשוות איברים בעלי ערך דומה. ˆ לכל j, נספור את מספר האיברים הקטנים מ j. COUNTING_SORT(A,B, n, k i n i t i a l i z e C[ k ] //O( k f o r i = 1 to n //O(n C[ A[ i ] ]++ f o r j = 2 to k //O( k C[ j ] = C[ j ]+C[ j 1] f o r j = n down to 1 //O(n B[ C[ A[ j ] ] ] = A[ j ] C[ A[ j ] ] זמן ריצה: k.θ (n + 9

4.1 הוכחת נכונות יהי A מערך בגודל n, אשר כל מספר בו הוא מספר טבעי בין 1 ל k. נראה כי האלגוריתם מחזיר את B ממוין. טענה 4.1 לאחר הלולאה הראשונה, לכל {k C [x] x,,1},... מכיל את מספר המופעים של x ב A. הוכחה: בלולאה הראשונה אנו עוברים על כל איברי המערך, ומקדמים את C באינדקס המתאים לאיבר ב A. טענה 4.2 לאחר הלולאה השניה, לכל {k C [x] x,,1},... מכיל את מספר המופעים של כל האיברים y עם y. x הוכחה: נוכיח באינדוקציה על j. טענה: בשלב ה j בלולאה השניה, [j] C מכיל את מספר המופעים של כל האיברים l עם l. j בסיס: עבור = 1 j הטענה הכונה באופן ריק. צעד: נניח כי הטענה נכונה ל 1 j. נשים לב כי על פי האלגוריתם, C[j] C. [j] = C j] [1 + מכיוון שעל פי הנחת האינדוקציה [1 j] C מכיל את מספר המופעים של כל האיברים l עם 1 j l, אזי כעת, משהוספנו את C[j] ל [j] C מתקיים ש [ j ] C מכיל את כל האיברים l עם l j כנדרש. מסקנה 4.3 לאחר הלולאה השניה, לכל {k C [x] x,,1},... מכיל את האינדקס הפנוי האחרון של x ב B. טענה 4.4 בשלב ה i של הלולאה השלישית, האיבר ה i n במערך הושם במקומו המתאים ב B. הוכחה: נשים לב כי מספיק להראות שבשלב ה i מתקיים שלכל {k C [x] x,,i},... מכיל את האינדקס הפנוי האחרון של x ב B, שכן אז על פי האלגוריתם, בשלב ה i, האיבר שב [ i A[n יושם במקומו. נוכיח באינדוקציה על i. טענה: בשלב ה i מתקיים שלכל {k x,1},... מתקיים אחד מהשניים: ב B. x מכיל את האינדקס הפנוי האחרון של C [x] 1. 2. האלגוריתם לא יגש יותר ל [ x ] C. בסיס: עבור = 1 i, המערך B ריק ולכן כל המקומות פנויים. מכיוון שלר שינינו את [x], C ממה שהסקנו קודם נסיק ש [ A[n אכן יושם במקומו. צעד: מהנחת האינדוקציה בשלב ה 1 i לכל {k C [x] x,,1},... מכיל את האינדקס הפנוי האחרון של x ב B, ולכן נוכל לשים את [i y = A[n במקומו המתאים. נשים לב, שלאחר ההשמה האלגוריתם מוריד את ערכו של [y] C ב 1. אם כעת [y] C מכיל מיקום חוקי של y, אזי בהכרח הו המקום הפנוי האחרון שלו. אחרת, הם הוא מכיל מיקום שאינו חוקי, אזי מבניית C אנו יודעים שזהו המיקום האחרון של 1 y, אך משמעות הדבר היא שעברנו ב A על כל ה y ים (שכן מספר ה y ים הוא בדיוק ההפרש בין [y] C ל [1 y] C, ולכן האלגוריתם לא יגש יותר אל.C[y] לכן טענת האינדוקציה מתקיימת. מסקנה 4.5 מכיוון שהטענה נכונה עבור, i = n נקבל שלאחר n הרצות של הלולאה, המערך כולו ממויין. 10

5 מיון ראדיקס Radix sort אליה. ידע מוקדם: כל איבר הוא מספר שלם בעל, לכל היותר, k ספרות. ולכל מספר הספרה הימנית יותר משמעותית מהספרה משמאל RADIX_SORT(A, k f o r i = 1 to k // from l e a s t s i g n i f i c a n t d i g i t B = COUNTING_SORT(A on d i g i t i A = B זמן ריצה: ((r k O. k n + מספר הספרות. r בסיס הספרות, טווח של כל ספרה. n מספר האיברים. 5.1 נכונות טענה 5.1 בכל שלב i בלולאה של האלגוריתם, המספרים ממוינים עד לספרה ה 1 i כולל. כלומר, לכל j נסמן.A[j] = a j k,..., aj 1 נגדיר מערך A עבורו לכל j מתקיים.A [j] = a j i 1,..., aj 1 הטענה טוענת כי אחרי השלב ה i באלגוריתם, A יהיה ממוין. הוכחה: נוכיח באינדוקציה על i, כלומר שלכל i n 1 הטענה נכונה. בסיס: עבור = 1 i הטענה מתקיימת על סמך הנכונות של.CountingSort צעד: נניח כי הטענה מתקיימת עבור 1 i, ונוכיח אותה עבור i. יהי a, b שני מספרים במערך, ונניח בה"כ (בלי הגדרת כלליות כי.a i,..., a 1 b i,..., b 1 בכדי לעמוד בהנחת האינדוקציה, עלינו להראות כי לאחר השלב ה i, a ימוקם במעדך לפני b. על פי האלגוריתם, בשלב ה i אנו ממינים את המערך לפי הספרה ה i. מכיוון ש a i,..., a 1 b i,..., b 1 ישנם שני מקרים אפשריים: b אכן ימוקם לפני a בעזרתו אנו ממיינים בכל שלב, לאחר השלב ה i, (אשר CountingSort על פי נכונות a. i < b i 1. במערך. 2. i a. i = b מכיוון שאנו ממינים בשלב זה לפי הספרה ה i, עקרונית, אין הבטחה על מיקומם היחסי של a ו b. עם זאת, מכיוון ש CountingSort הינו אלגוריתם מיון יציב, מובטח לנו כי הסדר הפנימי ישמר, כלומר שאם לפני כן a מוקם לפני,b אזי גם כעת הוא ימוקם לפני.b מכיוון ש, a i = b i ו,a i, a i 1,..., a 1 b i, b i 1,..., b 1 נקבל ש.a i 1,..., a 1 b i 1,..., b 1 לכן, מהנחת האינדוקציה נקבל שבשלב ה 1 i המספרים היו ממויינים במערך עד הספרה ה 1 i, ולכן בשלב ה i, a מוקם לפני b. כנדרש. מסקנה 5.2 מכיוון שהטענה נכונה עבור, i = n נקבל שלאחר n הרצות של הלולאה, המערך כולו ממויין. 6 מיון מהיר Quick sort מיון מהיר משתמש בשיטת ההפרד ומשול, המורכבת משלושה שלבים (בדומה למיון מיזוג: 11

הפרד חילוק המערך r] A[p,..., לשני תת מערכים (אולי ריקים, 1] q A[p,..., ו r].a[q + 1,..., כך שכל איבר ב [1 q A[p,,... קטן או שווה ל[ A[q, כאשר A[q] קטן או שווה לכל איבר ב [ r.a[q +,1,... חישוב הציר q הוא חלק משלב זה של החילוק. משול מיון שתי התתי מערכים [1 q A[p,,... ו [ r A[q +,1,... על ידי קריאות רקורקסיביות ל QuickSort. מיזוג כולו ממויין. מכיוון ששני התתי מערכים ממוינים במקומם, אין כל צורך בעבודה נוספת בכדי למזג אותם. המערך [r... A[p, עכשיו 2 QUICK_SORT(A, p, r i f p<r q = PARTITION(A, p, r QUICK_SORT(A, p, q 1 QUICK_SORT(A, q+1, r PARTITION(A, p, r x=a[ r ] i=p 1 f o r j = p to ( r 1 i f A[ j ]<= x i = i +1 exchange A[ i ] with A[ j ] exchange A[ i +1] with A[ r ] return i +1 התנהגות QuickSort נקבעת על ידי מיקום הציר q, בכל קריאה של P. artition T (n = T (n q + T (q 1 + Θ (n המקרה הגרוע ביותר החילוק הגרוע ביותר מתקיים כאשר בכל שלב באלגוריתם P artition מחלק מערך נתון לשני תתי מערכים, אחד בעל 1 n איברים ואחד בעל 0 איברים (האיבר הנוסף הוא הציר q: ˆ כאשר הקלט כבר ממויין (בסדר עולה או יורד..T (n = T (n 1 + T (0 + Θ (n = T (n 1 + Θ (n ˆ ˆ לאחר אינדוקציה (או איטרציה: 2.T (n = Θ ( n 12

המקרה הטוב ביותר (בקירוב. החילוק הטוב ביותר הוא כאשר בכל שלב P artition מחלק את המערך לשני תתי מערכים שווים בגודלם רנדומליות אם נבחר את האינדקס בצורה רנדומלית, נקבל זמן ממוצע של ((n T. (n = n log 6.0.1 נכונות נוכיח את נכונות QuickSort על סמך נכונות P. artition טענה 6.1 הפלט הוא מערך ממויין. הוכחה: נוכיח באינדוקציה על גודל הקלט מערך בגודל n. בסיס = 1 n, גודל המערך הוא 1, אזי p. = q הטענה נכונה באופן ריק. צעד נניח שהפלט של האלגוריתם עבור כל מערך שגודלו קטן מ n הוא מערך ממויין. נוכיח עבור מערך בגודל n. מכיוון שמניחים את נכונות P, artition לאחר הקריאה ל artition P הציר ממוקם במקומו הנכון במערך. כאשר כל האיברים במערך אשר גדולים מהציר, נמצאים מימינו, וכל האיברים השווים או קטנים לו נמצאים משמאלו. מכיוון ששתי הקריאות הרקורסיביות הבאות ל QuickSort הם עבור שני תתי מערכים הקטנים מ n, ניתן להסיק כי: ˆ הציר מונח במקומו הנכון במערך. ˆ התת מערך מימין לציר ממויין ומכיל רק איברים הגדולים מהציר. ˆ התת מערך משמאל לציר אף הוא ממוויין ומכיל איברים שווים או קטנים לציר. מסקנה: המערך ממויין. 7 משפט האב.Θ ( n k ואיחוד הפתרונות עולה, n b קיימת בעייה גדולה (מגודל n. מחלקים אותה ל a בעיות מאותו סוג, כל אחד בגודל ( n T (n = at + Θ ( n k b משפט 7.1 משפט האב. בהינתן נוסחת נסיגה מהצורה ( n T (n = a T + Θ ( n k b.q = a.כאשר: 1 b,k 0, constants : a, ו (1 Θ.T (1 = נסמן b k.1 אם < 1.q.T (n = Θ ( n k 13

.2 אם = 1.q.T (n = Θ ( n k log (n.3 אם > 1.q T (n = Θ ( n log ba הוכחה: משפט האב. קבוע חיובי: T (n T (b r d 1 q d 1 q nk d 1 q brk 1. אם < 1 q, נוכיח (d הוא קבוע חיובי כלשהו, ולכן גם T ( b 0 = T (1 d d 1 q 1k נוכיח באינדוקציה על r. בסיס = 0.r נניח שמשוואה 4.3 נכונה עבור כל r, ונוכיח עבור + 1 r. ( b T (b n r+1 a T + d b (r+1k = a T (b r + d b (r+1k b T (b n a d 1 q brk + d b (r+1k עבור r T (b נציב את משוואה :4.3 הוספה לחזקה (1 + r r וחילוק ב b k לא משנה את המשוואה: = a b k d 1 q b(r+1k + d b (r+1k q = a נזכור כי הגדרנו ש b k d = q 1 q b(r+1k + d b (r+1k d גורם משותף: נוציא 1 q b(r+1k = d 1 q b(r+1k (q + (1 q = d כלומר, קיבלנו כי: q b(r+1k 1 T (n d ולכן, בהכרח: q b(r+1k 1 ( n T (n a T + Θ ( n k T (n = Θ ( n k b כנדרש. 14

.T (n = O ( n k log n אז:,q = a.2 צ"ל: עבור נוסחת נסיגה מהצורה Θ(nk,T (n = at ( n b + כאשר = 1 k b.t (1 d וש,T (n at ( n b נניח ש,n = b r ו + dn k ( b T (b r r at + d (b r k b T (b r d (b r k log b (b r + d (b r k T ( b 0 = T (1 d d (b 0 k logb ( b 0 + d (b 0 k = d logb 1 + d k T ( b 0 d d k אזי: נוכיח באינדוקציה עבור כל r, כי: מקרה בסיס, עבור = 0 r: = 0 1,log ולכן: הראנו נכונות עבור מקרה בסיס, נניח נכונות עבור כל r ונוכיח נכונות עבור + 1 r. על פי הנחת התרגיל, עבור 1+r n: = b ( b r+1 T (n at + d b k(r+1 = at (b r + d b k(r+1 b ( נציב את הנחת האינדוקציה k T (b r d (b r k log b (b r + d (b r T ( b r+1 ( a d (b r k log b (b r + d (b r k + d b k(r+1 T ( b r+1 a d (b r k log b (b r + a d (b r k + d b k(r+1. a אזי: b k T ( b r+1 d a b k bk(r+1 log b (b r + d a b k bk(r+1 + d b k(r+1 k(r+1,a b k r = a b והנחנו ש: = 1 b k T ( b r+1 d b k(r+1 log b (b r + d b k(r+1 + d b k(r+1.log b b r + log b b = log b (b r b = log b ( b r+1 ו,log b b = 1 T ( b r+1 d b k(r+1 (log b (b r + 1 + d b k(r+1 T ( b r+1 d b k(r+1 (log b (b r + log b b + d b k(r+1 T ( b r+1 d b k(r+1 (log b ( b r+1 + d b k(r+1 15

הוכחנו את הנחת האינדוקציה עבור + 1,r לכן T (b r d (b r k log b (b r + d (b r k נכון עבור כל.r הוכחנו כי.T (n d (n k log b (n + d n k מכיוון ש d n k זניח ביחס ל (n,d n k log b כלומר: = k d n n.o ( d n k log b אזי: T (n d (n k log b (n T (n = O ( n k log n T (n = Θ ( n log ba ( : d q 1.3 אם > 1,q נוכיח: נרצה להוכיח שעבור קבוע חיובי כלשהו T (n = T (n d q 1 q nlog ba d q 1 q nlog ba d q 1 nk a T ( n במשוואת הנסיגה את המשוואה הקודמת נקבל: b מכיוון שאם נציב עבור T (b r d q 1 nk + T ( b 0 = T (1 d d q 1 nk T (n = d q 1 q (br logba d q 1 (br k d q 1 q (1log ba d q 1 (1k d q 1 q nlog ba עבור,n = b r נוכיח עבור כל :r נוכיח באינדוקציה על r. עבור מקרה בסיס = 0 r: = d q 1 q d q 1 ( : d q 1 נוציא גורם משותף = d q 1 (q 1 = d q 1 q 1 = d d = d המקרה בסיס מתקיים. נניח שמשוואה 4.5 נכונה עבור כל r, ונוכיח עבור + 1 r: T ( b r+1 ( b r+1 a T + d (b r+1 k b : br+1 b = b r T ( b r+1 a T (b r + d (b r+1 k 16

נציב עבור r T (b את משוואה :4.5 T ( b r+1 ( d a q 1 q (br logba d q 1 (br k + d (b r+1 k = a = b log ba ( d q 1 q (br logba d a q 1 (br k d (b r+1 k ( d q 1 q (br logba q b k,q = a לכן: b k d q 1 (br k d (b r+1 k a = q b k ו,a = b log ba ba(r+1,b k (b r k = b k(r+1,b log ba (b r logba = b log לכן: = d ( q d q 1 q blog ba(r+1 q 1 bk(r+1 d b k(r+1 = d q 1 q blog ba(r+1 d q 1 bk(r+1 (q (q 1 = d q 1 q blog ba(r+1 d q 1 bk(r+1 הוכחנו עבור + 1 r, לכן הנחת האינדוקציה נכונה עבור כל r. כנדרש. חסמים על מיונים הגדרה 7.2 תמורה (או: פרמוטציה חילוף המיקום בין שני מספרים. נסמן תמורה בעזרת האות σ. התמורה היא פונקציה מ 1 עד n, שהיא חח"ע ועל: σ : {1,..., n} {1,..., n} דוגמא: (8, 2, 5, 4 (2, 4, 5, 8 התמורות מתייחסות לשינוי לפי האינדקס של המיקום, ולא לפי הערך במיקום: σ (1 = 4, σ (2 = 1, σ (3 = 3, σ (4 = 2 טענה 7.3 כל אלגוריתם מיון על קלט בגודל n חייב לבצע לפחות n פעולות. 17

הערה 7.4 הנחה 1: האלגוריתם לא יודע את המספרים הרשומים במערך, גישה לכל מספר (לכל תא במערך עולה לפחות פעולה אחת. הערה 7.5 הנחה 2: האלגוריתם הוא "דטרמיניסטי" (לא קוונטי ולא הסתברותי. בפרט, הוא פועל בצורה זהה לשני איברים זהים. הוכחה: נניח בשלילה שקיים אלגוריתם מיון A שממיין נכון n איברים ועושה מקסימום 1 n פעולות. בפרט, A ממיין נכון את המערך n.b = (1, 2,..., קיים אינדקס k כך שכש A פועל על B הוא לא ניגש לתא k. נניח בלי הגדרת כלליות (בה"כ:.B = (1, 2,..., k,..., n,k n מכיוון שA לא קורא את האיבר ה k. A יפעל בצורה זהה על B ועל B. בפרט יחזיר את אות התמורה ולכן ימיין נכון את B. סתירה. אלגוריתם מיון מבוסס השוואות הגדרה 7.6 אלגוריתם שמחליט על הסדר של האיברים על סמך השוואה בלבד. כל מיון מבוסס השוואות מבצע ( Ω לפחות (n Ωפעולות. (n log דוגמאות למיון מבוסס השוואות:. bubblesort, MergeSort דוגמא למיון לא מבוסס השוואות:. bucketsort את תהליך ההשוואות ניתן לתאר באמצעות עץ אפשרויות (עץ בינארי... הוכחה: נניח בשלילה כי קיים אלגוריתם מיון הממיין בלכל יותר 1 n פעולות. נתבונן בריצה של האלגוריתם על קלט מסוים [n,...,2,1] בריצה הזאת האלגוריתם לא ניגש לתא מסוים במערך. נמסמן את התא הזה ב k, זאת אומרת, שעל קלט אחר [n,... k,1 (k,2n,...,2,1] האלגוריתם חייב לבחזיר את אותו הפלט (כי הוא רואה שני קלטים זהים. אך הפלטים הנכונים במקרה שלפנינו שונים לפחות ב (k n מקומות. סתירה. הערה: ההוכחה הזאת היא "טריוויאלית" כי ברור אינטיאוטיבית שלכל אלגוריתם חייב לקראו את הקלט שלו. ולכן זמן הריצה שלו הוא לפחות כגודל הקלט. חסמים תחתונים לאלגורתמי מיון מבוססי משוואות ˆ BubbleSort Θ ( n 2. ˆ MergeSort Θ (n log (n. ˆ QuickSort Θ (n log (n. משפט 7.7 כל אלגוריתם מבוסס השוואות הממיין מערכים בגודל n, חייב לבצע לפחות ((n Ω n log השוואות. ההנחה היא שהאלגוריתם לא רואה את המספרים הרשומים במערך, ולכן הוא יכול לשאול על תוצאות ההשוואה בין כל שני מספרים במערך. כל השוואה עולה לפחות פעולה אחת. 18

דוגמא: מיון בועות על קלט בגודל 3. לכל אלגוריתם מיון מבוסס השוואות ניתן להתאים עץ השוואות שהוא עץ בינארי עם שורש. הפלטים של האלגוריתם מתאימים לעלים של העץ (בכל עלה עומד פלט אפשרי. זמן הריצה של האלגוריתם המחזיר פלט מסוים שווה לאורך המסלול לעלה המתאים לפלט הזה (אלגוריתם יותר מתוחכם, עם תנאי עצירה מסוים, אם המערך ממויין ייעצר לפני העלה האחרון. הערה: לעץ השוואות כזה יש לפחות (!n עלים. הוכחה: לאלגוריתם יש (!n פלטים אפשריים, שהם כל הסידורים האפשריים של המספרים: ] n x], 1, x 2,,... x ולכל פלט חייב להתאים לפחות עלה אחד של העץ..Ω (n log 2 (n = n 2 log ( n טענה 7.8 יהי T עץ בינארי עם לפחות!n. אזי קיים עלה של T שמרחקו מהשורש הוא לפחות 2 2 הטענה גוררת את המשפט: "חסם תחתון לאלגרותמי מיון מבוססי השוואות", נניח את נכונות הטענה. יהי A אלגוריתם מיון מבוסס השוואות הממיין מערכים בגודל n. יהי T עץ השוואת שללו, לפי הטענה, קיים עלה בעץ שמרחקו מהשורש הוא לפחות ((n Ω. n log 2 זאת אומרת, שכדי להגיע לפלט הזה, האלגוריתם צריך לבצע לפחות ((n Ω n log 2 פעולות. הגדרה 7.9 גובה של עץ הוא המרחק המירבי בין שורש העץ לאחד העלים שלו. למה 7.10 לעץ בינארי בגובה k, יש לכל היותר 2. k הוכחה: נניח את נכונות הלמה. בהינתן כי הלמה נכונה, נראה נכונות של הטענה. יהי T עץ בינארי עם לפחות!n עלים. נסמן ב k את גובה העץ. לפי הלמה: נוכיח את הלמה: 2 k n! k log 2 (n! ( n ( n ( (n n log 2 (n! = log 2 (1 2... n log 2 2 + 1 2... n log 2 = n ( n 2 2 log 2 2 19

באינדוקציה על k. בסיס: = 1 k עבור עץ בינארי בגובה 1, העץ ייראה כך: או כך קל לבדוק כי לשני העצים האלה יש לכל היותר = 2 1 2 עלים. מעבר האינדוקציה: נניח את נכונות הטענה עבור (k,...,1 ונוכיח עבור + 1 k. =.T העצים T 1, T L, T R הם עצים בינארים עם גבהים.k 1, k L, k R מתקיים T 1 TL יהי עץ בינארי בגובה + 1 k, TR (.(k 1 = k max {k L, k R } = k חייב להיות (וגם k 1, k L, k R k TL ( העלים של T הם העלים של T 1 במקרה הראשון, T1 והם איחוד קבוצות העלים של T R, T L במקרה השני. TR לכן, לפי הנחת האינדוקציה, מספר העלים של T הוא לכל היותר 1+k 2 k1 2 k < 2 במקרה הראשון ולכל היותר = 1+k 2 2 k + 2 k 2 k L במקרה השני. + 2 k R ה"סידור סטטיסטי" של סט בעל n איברים, הוא האיבר ה i בקטנותו. 7.1 Order Statistics בעיית הסידור הסטטיסטי Problem-OSP (The Order-Statistic קלט: מערך A של n מספרים (שונים, ומספר.i כאשר i n.1 פלט: האיבר x A שבמדויק גדול יותר מ 1 i איברים אחרים ב A. פתרון טריוויאלי מיון על פי אחד מהאלגוריתמים ב ((n O, n log והחזרת הערך באינדקס i. קיים פתרון מהיר יותר, בזמן (n Θ: ˆ ביצוע P artition על המערך. אם,q = i נחזיר את.A[q] אם i, < q נבצע רקורסיבית P artition על המערך השמאלי. אם i, > q נבצע רקורסיבית P artition על המערך הימני. האינטואיציה לאלגוריתם הוא שבמקרה של,QuickSort אנו זקוקים למיין את שני צידי הציר q. אבל כדי למצוא את האיבר ה i, אנו זקוקים רק לתת מערך יחיד בכל קריאה רקורסיבית. זמן ריצה אם P artition יחלק תמיד את המערך לתת מערך בגודל 1 n, ותת מערך ריק. זמן הריצה הכולל יהיה על פי נוסחת הנסיגה: (n,t (n = T (n 1 + Θ ולכן זמן הריצה יהיה איטי: 2.Θ ( n.t (n = T ( n 2 אבל אם P artition יחלק את המערך לשני תתי מערכים שווים בגודלם, תתקבל נוסחת הנסיגה (n + Θ וחישוב על פי משפט האב יתן זמן ריצה כולל (n Θ. על מנת להתמיד בחילוק המערך באופן שווה, נבחר ציר q בצורה רנדומלית. 20

חלק II מבני נתונים 8 מבני נתונים מופשטים 8.1 שאלה אלגוריתמית ניהול של תהליכים על ידי מערכת הפעלה לכל תהליך קדימות משלו. רוצים להריץ בכל שלב את התהליך עם הקדימות המירבית ולתחזק את המערכת. פעולות שארצה לבצע ˆ לעדכן קדימויות. (להגדיר מה חשוב יותר לבצע קודם ˆ להכניס תהליך חדש. ˆ להוציא תהליך. ˆ למצוא את התהליך עם הקדימות המקסימלית. ˆ בניית המערכת. 8.1.1 תור קדימויות Priority Queue אנחנו מכירים רשימות עם זמן ריצה מסוים עבור הפעולות שהגדרנו: ˆ מחסנית,stack- LIFO יכול לנהל מערכת קדימויות רק לפי זמני הגעה. ˆ תור, queue - FIFO יכול לנהל מערכת קדימויות רק לפי זמני הגעה. ˆ מערך (ממויין ˆ רשימה (ממויין 21

נרצה להכיר סוג חדש של מבנה נתונים אשר מבצע את הפעולות הנ"ל בזמן קצר יותר. תור קדימויות הוא מבנה נתונים מופשט, בעל הפעולות הבאות: ˆ הכנסת ערך (A.O (log (n.insert O (1.Max (A ˆ ˆ הוצאת ערך מקסימלי (A.O (log (n.extractmax ˆ עדכון ערך. A.O (log (n.increasekey (x, k, תור קדימויות ניתן למימוש על ידי ערימה. הטבלה הבאה אינה פורמאלית (יכול להיות אלגוריתם עבור מערכים ורשימות ממוינות, העושה את הפעולות בזמן קצר יותר: פעולות מערך ממויין רשימה ממויינת ערימה (heap לעדכן קדימות (n log (n Θ (n Θ להכניס תהליך חדש (1 Θ log (n Θ (1 להוציא תהליך (n log (n Θ (n Θ למצוא את התהליך, עם קדימות מקסימלית (n log (n Θ (1 Θ בניית מערכת (n log (n Θ (n log (n Θ (n log 8.2 ערימה (heap ערימה היא עץ בינארי ממוין חלקית. הגדרה 8.1 עץ בינארי שלם זה עץ בינארי בו לכל קודקוד פנימי (זאת אומרת אינו עלה יש 2 בנים. כל העלים בעץ נמצאים באותו עומק, זאת אומרת אותו מרחק מהשורש. דוגמא: הגדרה 8.2 עץ בינארי כמעט שלם זהו עץ בינארי שכל הרמות שלו מלאות, כמו בעץ בינארי שלם, פרט, אולי, לרמה האחרונה שיכולה להיות חסרה כמה קודקודים מימין. 22

דוגמא: הגדרה 8.3 ערימה זהו עץ בינארי כמעט שלם, עם ערכים בקודקודים עם התכונה הבאה: הערך בקודקוד פנימי גדול מערכי בניו. (ערימת מינימום זה הפוך הקודקוד קטן מערכי בניו. נממש את הערימה בגודל n, בעזרת מערך [n A,1],... באופן הבא: השורש נכנס ל [1]A, הבנים של קודקוד שנכנס לתא ה i (הבנים של (A[i] הם: הבן הימני [1 +,A[2i הבן השמאלי [ A[2i.ואז המערך הוא בעל תכונת הערימה אם לכל i n 1 מתקיים: A[2i].A[i] > A[2i + 1],A[i] > [16, 14, 10, 8, 7, 9, 3, 1, 2, 4] A 1 2 3 4 5 6 7 8 9 10 index 0 1 1 2 2 2 2 3 3 3 level 23

8.3 פעולות של תור קדימיות (אלגוריתם של ערימה 8.3.1 עידכון ערך הקטנת ערך הפעולה מעדכנת את הערך של האיבר במקום ה i, בערך חדש x הקטן מהערך הנוכחי של [i] A. DECREASE_VALUE(A, i, x A[ i ]=x MAX_HEAPIFY(A, i השגרה (i MAX HEAPIFY(A, מקבלת כקלט מערך A שהוא בעל תכונת הערימה בכל מקום פרט, אולי, למקום ה i, ומתקנת אותו לערימת מקסימום תיקנית. MAX_HEAPIFY(A, i 24

i f A[ i ] > A[ 2 i ] & A[ i ] > A[ 2 i +1] // l o c a l t r e e i s ok e x i t i f A[ 2 i +1] > A[ 2 i ] then // r i g h t son i s b i g g e r swap (A[ i ], A[ 2 i +1] MAX_HEAPIFY(A, 2 i +1 // r e c u r s i v e c a l l e l s e i f A[ 2 i ]>A[ 2 i +1] // l e f t son i s b i g g e r swap (A[ i ], A[ 2 i ] MAX_HEAPIFY(A, 2 i // r e c u r s i v e c a l l זמן ריצה פעולת התיקון (i MAX HEAPIFY(A, עולה כגובה קודקוד i בעץ הערימה לכל היותר, כאשר גובה הקוקוד הוא המרחק המירבי שלו מהעלים. ולכן זמן הריצה של הפעולה הזו הוא לכל היותר גובה העץ כולו. למה 8.4 הגובה של עץ בינארי כמעט שלם עם n קודקודים מקיים.log 2 n 1 h log 2 n 1 + 2 + 4 +... + 2 h 1 < n 1 + 2 + 4 +... + 2 h 1 + 2 h הוכחה: 2 h 1 < n 2 h+1 1 נחליף סימן שוויון שמאלי, ונוסיף 1 (כי n מספר שלם, אז אם הוא גדול מ 1 h 2 אזי הוא גדול או שווה ל 2. h 2 h n 2 h+1 h log 2 n h + 1 log 2 n 1 h log 2 n הערה 8.5 במקרה של עדכון ערך שיותר גדול מערכי בניו, ניתן לעשות את אותו תהליך של,MAX HEAPIFY רק מלמטה לכיוון למעלה. עדכון הערך מתבצע על ידי "הצפה" למעלה הערימה כל עוד הערך גדול מאביו מתבצעת החלפה ביניהם. INCREASE_KEY(A, i, x { // assume x i s equal or l a r g e r then c urrent value A[ i ]=x while i >1 and A[ Parent ( i ] < A[ i ] swap (A[ i ], A[ Parent ( i ] i = Parent ( i // update index 25

הפעולות Max_Heapify ו Increase_Key מטפלים בבעיות שונות, Max_Heapify מתבצע כאשר ישנו ערך הקטן מערך ילדיו, ולכן קיים צורך לבחור בין שני אפשרויות. בעוד Increase_Key מתבצעת כאשר ישנו ערך הגדול מערך אביו, ולכן קיימת אפשרות אחת להחלפה. 8.3.2 החזרת ערך מקסימלי אלגוריתם המחזיר את הערך המקסימלי בערימה (הערך המקסימלי נמצא בשורש העץ. EXTRACT_MAX(A return A[ 1 ] A[ 1 ] = A[ heapsize ] heapsize MAX_HEAPIFY(A, 1 / / c o s t : l o g n זמן הריצה הוא כזמן הריצה של,MAX_HEAPIFY(A,i שהוא ((n O. (log נכונות בהינתן נכונות של, Max_Heapify נוכיח את נכונות.Extract_Max נצטרך להוכיח שתי טענות: ˆ הערך המקסימלי הוא זה שמוחזר. ˆ הערימה המעודכנת תקינה. טענה 8.6 השורש הוא הערך המקסימלי הוכחה: נניח בשלילה שהשורש אינו מקסימלי. אזי קיים איבר k, שאינו השורש, שערכו מקסימלי. מכיוון ש k אינו השורש קיים לו אב, עובדה הסותרת את התנאי לערימה תקינה. טענה 8.7 הערימה המעודכת תקינה. הוכחה: לאחר ביצוע החלפה בין האיבר האחרון (A[heapSize] לאיבר הראשון ([1]A והקטנת הערימה ב 1, מתקיים המצב הבא: ˆ שני תתי העצים של השורש השם ערימות תקינות, כי לא התבצע בהם שום שינוי. ˆ ההפרה היחידה המתקיימת היא בשורש. וזאת ההננחה היחידה לפיה ניתן לקרוא ל Max_Heapify. בהינתן נכונות Max_Heapify הערימה המעודכנת תקינה. 26

8.3.3 בניית הערימה נתון מערך [n,1]a,... ללא מבנה. רוצים להפוך אותו לערימה. BUILD_HEAP(A, n f o r i = n to 1 do MAX_HEAPIIFY(A, i משפט 8.8 זמן הריצה (n T של BUILD_HEAP הוא (n.o נכונות האלגוריתם (ז"א נראה כי הוא מחזיר ערימה חוקית תנאים לנכונות הערימה כאשר מתבצעת קריאה לשיטת,Max_Heapify מתקיימת ההנחה שהתתי עצים של בניו של האיבר k הם ערימות תקינות, והמקום היחידי בו מתקיימת הפרה של תכונת הערימה היא בין האיבר ה k לאחד מבניו. פעולת Max_Heapify נכונה רק אם הנחה זו מתקיימת. הוכחה: באינדוקציה יורדת על i. נוכיח באינדוקציה כי אחרי פעולת MAX_HEAPIFY(A,i כל העצים עם שורש ב A[n] A[i],,... יהיו ערימות חוקיות. אם נצליח להוכיח נכונות, אחרי הפעולה האחרונה, העץ עם שורש ב [1]A הוא ערימה חוקית, לכן A כולו הוא ערימה חוקית. בסיס: i. = n אחרי n פעולות, העץ עם שורש A[n] הוא ערימה חוקית (בכל מקרה הוא עלה עץ בגודל 1. מעבר: נניח נכונות הטענה האינדוקטיבית עבור i +,1 n... ונוכיח נכונות עבור i. הפעולה MAX_HEAPIFY(A,i מקבלת כקלט עץ בינארי כמעט שלם עם שורש ב[ A[i. שני תתי העצים שלו מושרשים ב [ A[2i, A[2i + [1 לפי הנחת האינדוקציה הן ערימות חוקיות. לפי תכונות הפעולה MAX_HEAPIFY(A,i, היא הופכת את העץ עם השורש ב A[i] להיות ערימה חוקית גם הוא. זמן ריצה זמן ריצה (n T של בניית ערימה הוא בגודל n. T (n = n T (MAX HEAP IF Y (A, i Θ (log (n i + 1 i=1 ( n = Θ log (n i + 1 i=1.(1 + i n מספר האיברים שעדיין לא נעשה עליהם פעולת MAX_HEAPIFY (על פי צעד האינדוקציה. 27

n n 2 log 2 (n i + 1 log 2 (n i + 1 i=1 i=1 i=1 = n ( n 2 log 2 Ω (n log (n 2 נוכיח כי הביטוי גדול יותר מקבוע כפול (n n. log n 2 ( n log 2 2 למה 8.9 נוכיח כי זמן הריצה של בניית הערימה היא (n T. (n = O אבחנה: זמן הריצה של פעולת MAX_HEAPIFY שווה ל swaps (number of 4 2 (עבור + כל החלפה מתקיים 4 פעולות השוואה של האב לשני בנים, עוד 2 השוואות בין בן ימין לשמאל וההפך, וההחלפה עצמה. ובנוסף במקרה ששני הבנים T (n = n T (MAX HEAP IF Y (A, i = i=1 = 2n + 4 קטנים מהאיבר ואין צורך להמשיך ברקורסיה, נעשים עוד 2 פעולות n T (2 + 4 #swaps (MAX HEAP IF Y (A, i i=1 n T (#swaps (MAX HEAP IF Y (A, i = 2n + 4 i=1 n #swaps (x k אם סופרים את מספר האיברים העולים, נצטרך לחלק ב 2. כי כל איבר נספר פעמיים(בדרך למטה, ובדרך למעלה. כל איבר שנעשה עליו שינוי בתהליך, קודם יורד, לאחר מכן הוא יכול רק לעלות. הוא אינו יכול לרדת לאחר שהתחיל לעלות. לכן, לא יכול להיות שהאיבר יגיע, בכל רגע נתון, לרמה שהיא מעל הרמה של מיקומו הסופי. מכיוון שכך ניתן לחלק ב 2 את מספר הפעולות 2n + 4 1 2 2n + 4 n #swaps (x k = 2n + 4 k=1 k=1 על האיבר, כדי לקבל את מס' הפעמים, לכל היותר, שהאיבר עולה. n #swaps (x k moves up k=1 n #swaps (x k moves up 2n + 4 k=1 גובה העץ h. הרמה של האיבר x k בערימה הסופית d. k n (h d k h d k כמות הפעמים המקסימלית שהאיבר x k יכול לעלות בעץ. נשנה את האיטרציה, כך שתרוץ על הרמות מהשורש עד הקצה, ותחשב את הפעולות שעושה כל איבר (לפי הרמה שבו הוא נמצא. 2n + 4 k=1 ( h 2n + 4 2 h m m = 2n + 4 2 h m=0 k=1 בכל רמה j קיימים לכל היותר 2 j איברים. n h (h d k 2n + 4 2 j (h j j=0 h m 2 m 2n + 4n m=0 נגדיר,m = h j ולכן.j = h m h m 2 m m=0 28

2 m = m t=0 ( m t ( m + 0. h למה 4 8.10 2 m m=0 m הוכחה:.1 נראה כי לכל m טבעי מתקיים.m 2 2 2 m.(2 m = (1 + 1 m = m ( m t=0 t (כי.2 m = m ( m טריק: t=0 t עבור 2 :m ( m + 1 ( m m (m 1 = 1 + m + 2 2 ( m 2 m 2 + m + 2 = 2 + 2m + m (m 1 = 2 1 + m + m (m 1 2 2 m 2 ולכן h m 2 m m=0 h m=0 ( m 2 2 2 2 m = 2 h 2 m 2 2 m=0.2 הוכחנו כי 2 m m 2 m 2 2 m 2.2 ולכן: m=0 ( 1 2 m = 2 1 1 1 2 4.q = 1 2 q < 1 m=0 qm = 1 1 q :( h לכן, קיבלנו שזמן הריצה עבור בניית ערימה הוא ליניארי, (n T. (n = O ובפרט (על פי הוכחת הלמה 4 m 2 0=m m 2n + 4 n #swaps (x k moves up 2n + 4n k=1 h m 2 m 2n + 4n 4 = 18n m=0 8.4 סידור בעזרת ערימה בהינתן מערך המסודר כערימה, ניתן למיין את המערך בסדר עולה באמצעות.HeapSort השלבים באלגוריתם: ˆ בניית ערימה ממערך נתון. ˆ החלפת שורש הערימה (בעל הערך המקסימלי עם האיבר האחרון במערך. ˆ בהינתן כי המקום האחרון במערך מכיל את הערך המקסימלי, הקטנת המערך באחד על ידי החסרת התא האחרון מהמערך. ˆ בהינתן כי המקום היחידי בו יכולה להתקיים הפרש של תכונת הערימה היא בשורש (כי הוא המקום היחידי שהתעדכן בערך חדש ביצוע פעולת Max_Heapify על השורש במערך החדש, ˆ ביצוע חוזר של השלבים לעיל, עד שנשאר מערך בעל ערך יחיד הערך המינימלי. 29

HEAPSORT(A, n BUILD_HEAP(A, n //O(n f o r i = n to 2 swap (A[ 1 ], A[ i ] //O( 1 MAX_HEAPIFY(A, 1, i 1 //O( l o g (n זמן ריצה (n.o (n log 9 עצי חיפוש בינאריים Trees BST (Binary Search איבריו של עץ חיפוש בינאריים ממוקמים כך שהם תמיד מקיימים את תכונת החיפוש: תכונת החיפוש יהי x איבר בעץ חיפוש בינארי. אם y הוא איבר בתת עץ השמאלי של x, אזי ערך y קטן מערך x. אם y הוא איבר בתת עץ הימני, אזי ערך y גדול מערך x. למען הפשטות, נניח שכל הערכים שונים. החיסרון של BST הוא שהעץ לא תמיד מאוזן. פתרון: נעבוד רק עם עצים מאוזנים (הגובה: ((n n h, = O (log מספר הקודוקודים. מינימום הגדרה 9.1 מינימום של עץ חיפוש בינארי הוא האיבר השמאלי ביותר בעץ. מקסימום הגדרה 9.2 מקסימום של עץ חיפוש בינארי הוא האיבר הימני ביותר בעץ. 30

9.1 אלגוריתם הכנסת איבר נגדיר שני מצביעים: 1. מצביע x עובר על העץ. 2. מצביע y מצביע על האבא של x. INSERT(T, z x = root (T, y = NULL while ( x!= NULL y = x i f key ( z<key ( x x = l e f t ( x e l s e x = r i g h t ( x i f ( y = NULL root (T = z e l s e i f ( key ( z < key ( y l e f t ( y = z e l s e r i g h t ( y = z זמן ריצה של INSERT הוא (n n Θ, גובה העץ. 9.2 יורש הגדרה 9.3 היורש (Successor של איבר x, הוא האיבר בעל הערך בקטן ביותר מבין האיברים בעלי ערך הגדול מערך x. מציאת היורש בעץ. חיפוש בינארי חיוני עבור פעולות רבות, וחיוני בתור פעולה עצמאית. TREE_SUCCESSOR( x i f ( r i g h t ( x!= n u l l return Tree_min ( r i g h t ( x e l s e y = parent ( x while ( y!= n u l l and ( x!= l e f t ( y 31

// keep on climbing up, to the l e f t o f current x x = y y = parent ( x return y נכונות טענה 9.4 אם y יורש של x אזי: ˆ אם ל x קיים בן ימני w, אזי y הוא המינימום של תת העץ של w. ˆ אם ל x לא קיים בן ימני. אזי מתקיים אחד מהשניים: x מקסימלי האיבר הימני ביותר בעץ, ולכן לא קיים לו יורש. y הוא הקדמון (ancestor הקרוב ביותר ל x כך שבנו השמאלי של y הוא x או קדמון בעצמו של x (ושבנו השמאלי אינו קדמון של x, כלומר הוא קדמון ל x דרך בנו הימני. למה 9.5 יהי x איבר בעץ חיפוש בינארי, אזי כל איבר z שאינו נמצא בתת עץ של x (x T, ערך z אינו נמצא בטווח בין של.value (z / [min (T (x, max (T (x] כלומר.T (x הוכחה: מכיוון שקיים מסלול יחיד משורש העץ לכל קודקוד, קיימים 4 אפשרויות ליחס בין x ל z, כאשר u הוא קדמון משותף ל x ו z : max (T (x < z ˆ.z < min (T (x ˆ.z < u < min (T (x ˆ.max (T (x < u < z ˆ טענה 9.6 אם ל x קיים בן ימני w, אזי היורש של x הוא המינימום של תת העץ של w (w T. הוכחה: ראשית, נוכיח כי היורש נמצא בתת עץ של x. על פי הגדרה היורש הוא האיבר המינמלי מבין כל האיברים הגדולים מ x. כל האיברים הגדולים מ x נמצאים בתת עץ של בנו הימני (w T. על כן היורש הוא האיבר המינימלי מבין כל האיברים ב ( w,t כלומר (w.min (T נוכיח כי היורש בהכרח אינו נמצא מחוץ לתת עץ של x. על פי הלמה, עבור כל z שאינו ב ( x T ערך z אינו בטווח [((x,[min T ((x, max T כל שכן שהוא אינו בטווח [((w,x]. min T לכן, אין אף איבר בכל העץ חיפוש בינארי שערכו גדול מ x אך קטן מ ((w.min T לכן, ((w min T הוא היורש. 32

9.3 מחיקת איבר ˆ אם x הוא עלה, נשנה את המצביע אליו מאביו ל.null ˆ אם ל x קיים בן יחיד y, נשנה את המצביע מאביו של x אל x, למצביע מאביו של x לy. כך "נעקוף" את x ונתעלם ממנו. ˆ אם ל x קיימים שני בנים, נמצא את היורש של x y. נעדכן את ערכו של x בערכו של y, ונמחק רקורסיבית את y. (לכל היותר קיים ליורש y בי (ימני יחיד. TREE_DELETE(T, x i f l e f t ( x= n u l l or r i g h t ( x= n u l l //x has a s i n g l e c h i l d at most c h i l d = l e f t ( x i f c h i l d = n u l l c h i l d =r i g h t ( x i f x = l e f t ( parent ( x //x i s a l e f t son l e f t ( parent ( x = c h i l d e l s e //x i s a r i g h t son r i g h t ( parent ( x = c h i l d d e l e t e x e l s e //x has 2 c h i l d r e n // apply s u c c e s s o r value and d e l e t e s u c c e s s o r y = s u c c e s s o r ( x value ( x = value ( y TREE_DELETE(T, y 9.4 קוטר העץ מרחק הגדרה 9.7 מרחק בעץ היא פעולה לכל קבוצה A, שעבור,x,y z A מתקיים (d הוא המרחק בין שני קודקודים: ˆ הגדרת מיקום: > 0 y d (x, ו = 0 y d (x, אמ"ם.x = y ˆ סימטריות: x.d (x, y = d (y, ˆ אי שיוויון המשולש: z.d (x, z d (x, y + d (y, נגדיר את המרחק בגרף, עבור קבוצת קודקודים V: לכל d,v (u,u: v V הוא המסלול הקצר ביותר בין uל v. 33

9.4.1 קוטר העץ מכיוון שעץ הוא סוג של גרף, הגדרת המרחק עבור גרפים מתקיימת גם בעצים. הגדרה 9.8 קוטר העץ הוא המסלול הארוך ביותר (מבין כל המרחקים המסלולים הקצרים בין שני קודקודים ( 1 המתקיים בין שני קודקודים בעץ, v.d (T = max u,v d (u, מציאת קוטר העץ הרעיון למציאת הקוטר הוא לבצע אלגוריתם רקורסיבי שמוצא את הקוטר של התת עץ הימני של השורש, את הקוטר של תת העץ השמאלי של השורש. וסכום המסלול הארוך ביותר מהשורש לסוף העץ הימני, והמסלול הארוך ביותר מהשורש לסוף העץ השמאלי (כלומר, גובה תת העץ השמאלי+גובה תת העץ הימני+ 2. בכל שלב נצטרך את גובה תת העץ וקוטרו. TREE_DIAMETER(X // r e t u r n s ( height, diameter I f x = n u l l return ( 1, 1 ( left_h, left_d = TreeDiameter ( l e f t ( x ( right_h, right_d = TreeDiameter ( r i g h t ( x return (max( left_h, right_h +1,/ * height */ max( right_d, left_d, left_h+right_h +2/ * diameter */ זמן ריצה סיבוכיות כמספר הקודקודים בעץ ( V Θ. 10 עצי (Adelson-Velskii Landis AVL הגדרה 10.1 עץ בינארי הוא בעל תכונת,AVL אם לכל קודקוד פנימי בעץ מתקיים: ((x h (left ((x h (right 1 (תנאי מקומי. טענה 10.2 הגובה hשל עץ AVL עם n קודקודים מקיים (n.h = O (log ( 1+.( n ( 5 3 n קודקודים (התשובה המדויקת יותר היא 2 2 למה 10.3 בעץ AVL בגובה h יש לפחות הוכחה: באינדוקציה על n. בסיס: נראה עבור שני המקרים הראשונים..n = 1 ( 3 0 2 = 1 :h = 0 n 2 ( 3 1 2 = 3 2 :h = 1 1 בעץ קיים רק מסלול יחיד בין כל שני קודקודים, לכן המסלול הקצר ביותר הוא המסלול היחיד 34

צעד: נניח את נכונות הטענה עבור [1 h,...,1]. ונוכיח עבור h. נסמן n h כמספר הקודקודים המינימלי האפשרי של עץ AVL בגובה h..1 נראה כי מתקיים h 1.n h n h 1 + 1 > n h 1 :n h > n 2. נראה כי מתקיים 2 h n. h > n 1 h + n אנו יודעים עכשיו איך נראה עץ AVL עם מספר קודקודים מינימלי בגובה h. קיבלנו נוסחה רקורסיבית: n h = n h 1 + n h 2 + 1 > n h 1 + n h 2 ( 3 h 1 2 ( 3 h 2 = 2 ( h 1 3 + 2 ( h 1 3 + 2 ( 1 3 = 3 2 2 3 2 + 1 > ( h 2 3 2 ( h 2 3 > 2 ( 3 2 h 2 = ( h 3 2 : ( 3 h 2 2 נראה כי האי שיוויון באמת מתקיים. נחלק כל אגף ב ( 3 h ( 2 2 3 = 9 2 4 ( 2 3 10 2 4 > 9 4 n הוכחה: הלמה גוררת את הטענה. נניח את נכונות הלמה, ונוכיח את הטענה. :n ( 3 h 2 יהי T עץ AVL עם n קודקודים. ויהי h הגובה של T. לפי הלמה ( h 3 3 n log 2 2 2 log 2n n 1 3 log (n h = O (log (n log 2 2 10.1 מציאת קוטר עץ AV L נתון שכל קודקוד בעץ מכיל את גובהו בעץ. AVL_DIAMETER( Node n i f n = n u l l reuturn 0 e l s e return ( r i g h t (n. height + l e f t (n. height + 2 35

טענה 10.4 קוטר עץ AV L בעל גובה h, הוא לכל היותר 2h. הוכחה: באינדוקציה על h. בסיס = 0.h אזי הקוטר הוא. 0 צעד נניח נכונות עבור 1 h, ונוכיח עבור h. אם הקוטר, כלומר המסלול הארוך ביותר בין שני קודקודים בעץ, עובר דרך השורש. ידוע כי קוטר כזה הוא סכום הגבהים של שני תתי העצים + 2 + 2, R.height(n L + height(n מתכונת AV L ידוע כי גובהו של תת עץ של השורש יהיה לכל היותר 1 h. אזי לכל היותר הקוטר הוא: 2 (h 1 + 2 = 2h 2 + 2 = 2h אם הקוטר אינו עובר דרך השורש, אלא באחד תתי העץ של השורש. על סמך נכונות האינדוקציה ניתן להסיק כי מתקיימת הטענה על תת עץ בגובה 1.h ואמנם מתקיים, (h 1 < 2h.2 נכונות האלגוריתם נוכיח כי קוטר עץ AV L בהכרח עובר דרך השורש. השמאלי/ימני. כלומר, סכום גבהי תתי העצים + 2, גדול יותר מקוטר תת העץ הוכחה: על פי הטענה שהוכחה לעיל, ידוע כי קוטר תת העץ הימני או השמאלי הוא לכל היותר (1 h 2. כמו כן, על פי תכונת,AV L סכום תתי העצים הוא לפחות 3 2h.(h 1 + (h 2 = אזי מתקיים כי סכום תתי העצים בתוספת 1 : 2 2h 2h, 3 + 2 = גדול מערכו המקסימלי האפשרי של קוטר תת עץ:.2 (h 1 = 2h 2 2h 1 > 2h 2 10.2 הכנסת איבר Insertion לאחר הכנסת איבר לעץ,AV L יש צורך "לטפס" במעלה העץ כדי לבדוק אם פעולת ההכנסה גרמה להפרה של תכונת העץ.AV L אם קיימת הפרה, יש צורך בפעולת תיקון שתחזיר את תכונת ה L AV (הפרשי הגבהים בין שני תתי עצים אינו גדול מ 1, ויחד עם זאת תשמור על תכונת ה BST (ערך הבן השמאלי קטן מערך האב, שקטן מערך הבן הימני. עבור שורש העץ קיימים 4 "נכדים", עבור כל הכנסה לתת עץ של כל נכד קיימת פעולה מתאימה על מנת לתקן את העץ. פעולת התיקון היא "סיבוב" העץ, כך שיתקיימו התכונות הרצויות (מפורט בתרגול. 10.3 מחיקת איבר Deletion בעקבות מחיקת איבר מהעץ, גובהו של העץ השתנה. לכן, יש צורך "לטפס" במעלה העץ כדי לבדוק אם קיימת הפרה של תכונת ה L.AV תנאי העצירה עבור הבדיקה הוא כאשר האלגוריתם מגיע לקודקוד שגובהו לא השתנה, או אם הגיע לשורש העץ. 36

זמן ריצה הריצה הוא (n.θ (log כל סיבוב של תת עץ עולה בזמן ריצה קבוע, מכיוון שלכל היותר קיימים (n log קודקודים שצריכים תיקון, זמן 11 גרפים גרף הוא מבנה נתונים מופשט, נסמן את V כמספר הקודקודים, ו E כמספר הצלעות. (E G. =,V ניתן לייצג את הגרף באמצעות מבנה נתונים אחר: מטריצת שכנויות מטריצה ריבועית (בעלת מספר שווה של שורות ועמודות, אשר מספר השורות/עמודות הוא כמספר הקודקודים בגרף. עבור כל מיקום בגרף a, i,j ישנו ערך המייצג את משקל הצלע המחברת בין הקודקודים i ו j. אם לא קיימת צלע כזו, הערך הוא 0. מטריצת שכנויות בינארית מטריצה שמורכבת מערכים של 1 או 0. אם קיים 1 בתא ה a, i,j אזי קיים צלע המחברת בין הקודקודים i ו j. אם קיים, 0 אזי אין צלע המחברת בין הקודקודים. למטריצה זו, יש תכונות מעניינות, כמו למשל: הכפלת המטריצה בעצמה n פעמים, תיתן מטריצה אשר ערך כל תא מייצע את מספר הדרכים שניתן להגיע מ i ל j ב n צעדים. רשימת שכנויות רשימה משורשרת של רשימות משורשרות רשימה באורך מספר הקודקודים בגרף ( V, אשר האיבר ה i ברשימה הוא ראש של רשימה משורשרת באורך מספר שכניו של האיבר ה i. כאשר בכל תא קיים מספר השכן (זהותו ומשקל הצלע המחברת אותו אל האיבר ה i. הגדרה 11.1 גרף לא מכוון: גרף שצלעותיו ללא כיוון (דו כיווניים. הגדרה 11.2 גרף מכוון: גרף שצלעותיו בעלי כיוון מסוים (חד כיווניים. 11.1 אלגוריתמים על גרפים שאלה פשוטה: בהינתן קודקוד v, V מי הם ה"חברים" של v (ז"א, השכנים של v בגרף? 11.1.1 מימוש של גרף (ייצוג של גרף נממש באמצעות רשימת שכניות. 37

11.1.2 כמות הזיכרון הנדרשת O ( V + E 11.1.3 זמן ריצה זמן הריצה לאלגוריתם העונה על השאילתה לגבי השכנים של קודקוד v V הוא (v O. # of neighbours of שאלה יותר קשה: בהינתן s, G צריך, לכל קודקוד v G לחשב את המרחק בגרף מ v ל s : δ.,v (s 11.2 אלגוריתם חיפוש רוחב בגרף Search BFS(Breadth First קלט: גרף G המיוצג על ידי רשימת שכינויות וקודקוד התחלה S. האלגוריתם בונה ומשתמש בתור Q. לכל קודקוד v יותאם שדה (v, dist שבסופו של דבר מכיל את המרחק מ s ל v. BFS (G, S f o r A l l v in V, d i s t ( v= i n f i n i t y d i s t ( s =0 ENQUEUE(Q, s // i n s e r t s to Queue (Q While Q i s not empty u = DEQUEUE(Q // get u from Queue f o r a l l v : ( u, v in E // a l l neighbours o f u i f d i s t ( v = i n f i n i t y ENQUEUE(Q, v // i n s e r t v to Queue d i s t ( v = d i s t (u+1 מרחק: 7 1, 2, 3, 4, 5, 6, כל השאר L יצאו מהתור B התור Q,,..., 1,.., 7 Ø Ø 0, 1,,...,, 1, 1 2,..., 7 Ø 1 0, 1,,...,, 1, 1 3, 4, 5 1 2, 7, 6 0, 1, 2, 2,, 1, 1 5 1, 2 7, 6, 3, 4 0, 1, 2, 2,, 1, 1 5 1, 2, 7 6, 3, 4 0, 1, 2, 2, 3, 1, 1 Ø 1, 2, 7, 6 3, 4, 5 0, 1, 2, 2, 3, 1, 1 Ø.. 0, 1, 2, 2, 3, 1, 1 Ø 1, 2, 7, 6, 3, 4, 5 Ø זמן ריצה 11.2.1 משפט 11.3 זמן הריצה של BFS הוא E.O ( V + הוכחה: 38

ˆ זמן העבודה עם התור Q הוא ( V O (על פי זמן ריצה של הכנסת והוצאת ערך מהתור. ˆ זמן המעבר, פעם אחת בלבד על רשימות השכנים של כל הקודקודים בגרף (עוברים על רשימת השכנים של קודקוד u, V ברגע שהוא יוצא מהתור הוא כגודל הכולל של כל רשימות השכנים וזה ( E O. 11.2.2 נכונות משפט 11.4 בסוף הריצה, לכל קודקוד מתקיים (s,dist (v = δ,v כאשר (s δ,v מסמן את המרחק האמיתי של v מ s בתוך.G הוכחה: הוכחת נכונות היא באינדוקציה על k, שהוא גודל קבוצת הקודקודים (B שכבר יצאו מהתור. נסמן את גודל B כ k. נוכיח טענה באינדוקציה על V k :0 טענה 11.5 לכל k. =,0,.. v k, אחרי שהוצאו k איברים מהתור, מתקיימים שלושה התנאים הבאים:.1 נסמן Q k המצב הנוכחי של התור, } t.q k = {v 1,..., v אזי מתקיים: t dist (v 1 dist (v 2...dist (v.dist (v 1 + 1.2 לכל הקודקודים v בתור,Q k ובקבוצת הקודקודים B k שכבר יצאו מהתור, מתקיים s.dist (v = δ (v, 3. נסמן L k קבוצת האיברים שלא נכנסו לתור. לכל קודקוד u L k שעוד לא נכנס לתור = (u.dist מתקיים.δ (u, s dist (v 1 + 1 נשים לב, כי מספיק להוכיח את הטענות 1,2,3 כדי להוכיח את המשפט. אמנם, בסוף ריצת האלגוריתם k, = V ולכן כל.dist (v = δ (v, s ולפי טענה, 2.v B k מקיים v V בסיס האינדוקציה = 0,k.L 0 = V \ {s},b 0 = Ø,Q 0 = {s} = 0.1 (s,dist התנאי מתקיים באופן ריק..2 s.dist (s = 0 = δ (s, מתקיים..3 לכל,v L 0 מתקיים = (v,dist ו + 1 (s.δ (v, s 1 = dist מעבר האינדוקציה נניח נכונות ל k ונוכיח ל + 1 k..l k = {u 1,..., u m },B k = {w 1,..., w k },Q k = {v 1,..., v t }. L k+1 = {u r+1,..., u m },B k+1 = {w 1,..., w k, v 1 },Q k+1 = {v 2,..., v t, u 1,..., u r } נבדוק את נכונות התנאים 2 1, ו 3..1 נסמן 1,d = dist (v כאשר v 1 הוא האיבר הראשון בתור בשלב.k + 1 d,dist (v 1 dist (v 2...dist (v t על פי תנאי 1 בהנחת האינדוקציה. מצד שני, הקודקודים החדשים הם שכנים של v, 1 ולכן שדה המרחק שלהם עודכן ל + 1 1 d. + 1 dist v ולכן מתקיים.d dist (v 2... dist (v t d + 1 = dist (u 1 =... = dist (u r d + 1 39

B k זה Qk נשים לב כי עבור הקודקודים ב,dist (v = δ (v, s מתקיים B k+1 2. צ"ל כי לכל הקודקודים ב Qk מתקיים לפי הנחת האינדוקציה (תנאי 2 של ההנחה ולכן נשאר לבדוק את הטענה עבור uשעברו 1,,... u r 1+k Q מתוך.δ (u, s = d נשאר לבדוק + 1.dist (u = d מתקיים + 1 u {u 1,..., u r } לכל קודקוד.L k על פי תנאי 3 הנחת האינדוקציה מתקיים כי.δ (u, s dist (v 1 + 1 = d + 1,u L k מצד שני, על פי טענה 2 של הנחת האינדוקציה, מתקיים + 1 d,δ (u, s δ (v, s + 1 = ולכן + 1 d.δ (u, s =.3 צ"ל כי לכל k+1 u L מתקיים = (u dist וזה ברור. וגם כי + 1 2.δ (u, s dist (v ישנם שתי אפשרויות : (א,dist (v 2 = d לפי הנחת האינדוקציה (3 1 + d.δ (u, s dist (v 1 + 1 = כנדרש. (ב + 1 d,dist (v 2 = הבעיה היחידה שיכולה להיווצר היא אם + 1 d,δ (u, s = וזאת צריך לסתור, נוכיח שזה לא יכול להתקיים: למה + 2 11.6 d.δ (u, s הוכחה: נניח בשלילה כי + 1 d δ,,u (s = יהי x הקודקוד האחרון לפני u בדרך הקצרה מ s ל u. ולכן מתקיים?x נשאלת השאלה, איפה נמצא הקודקוד.δ (x, s = d נוכיח ש x אינו נמצא באף אחת מהקבוצות B k Q, k או L. k ולכן uאינו נמצא ב 1+k B 1+k Q, או 1+k L. נשים לב, כי לפי הנחת הלמה, שדות המרחק ב Q k נראה כך: d = dist (v 1 dist (v 2 = d + 1 =... = dist (v t נראה כי.x / Q k נניח,x Q k אזי לפי הנחת האינדוקציה,(2 1.dist (x = δ (x, s = d x = v ולכן, זה היה גורר k+1,u Q סתירה (כי ע"פ ההנחה k+1.(u L נראה כי x, / B k אחרת בשלב בו x נשלף מתוך התור, u היה נכנס לתור. בסתירה לך ש 1+k u. L נראה כי.x / L k ע"פ ההנחה באינדוקציה (3 לכל קודקוד,δ (y, s dist (v 1 + 1 = d + 1,y L k בסתירה לכך ש s.d = δ (x, 11.3 אלגוריתם חיפוש עומק בגרף Search DFS (Depth First אלגוריתם ה"מגלה" את הגרף לעומק, לצורך כך משתמש במתודת עזר.Explore המתודות POSTVISIT ו PREVISIT הם מתודות עזר, הקובעות את זמן הכניסה/יציאה מכל קודקוד. EXPLORE(G, v v i s i t ( v=1 PREVISIT( v f o r each w in (w, v from E i f v i s i t e d (w=0 40

POPSTVISIT( v EXPLORE(G, w אלגוריתם DFS DFS(G f o r each v in V v i s i t e d ( v=0 f o r each v in V i f ( v i s i t e d ( v == 0 EXPLORE(G, v זמן ריצה האלגוריתם עובר על כל הקודקודים בגרף, ועל כל צלע לכל היותר פעמיים. על כן זמן הריצה של DF S הוא.O ( V + E סוגי צלעות Edge Types עץ לעומק, הוא מסלול הנוצר בגרף לאחר הרצת.DF S ˆ צלעות עץ edges (Tree הצלע (v, u הוא צלע עץ אם בהרצת v,df S התגלה לראשונה דרך צלע זו. ˆ צלעות לפנים edges (Forward הצלע (v, u היא צלע לפנים, אם היא מחברת את u לצאצא שלה v בעץ לעומק, והיא אינה צלע עץ. ˆ צלעות לאחור edges (Backward (v,u היא צלע לאחור, אם היא מחברת את u לקודקוד קדמון שלה בעץ לעומק. כולל לולאות עצמיות צלע המתחברת לקודוקד ממנו יצאה. ˆ צלעות צולבות edges (Cross כל שאר הצלעות בגרף, הם יכולים לחבר בין צלעות באותו עץ לעומק, כל עוד קודקוד אחד אינו צאצא של השני. או לחבר בין קודקודים הנמצאים בעצי עומק שונים. גרפים ללא מעגל Graphs DAG (Directed Acylic הגדרה 11.7 מעגל בגרף הוא תת קבוצה של קודקודים } k,{v 1,..., v כך שלכל i = 1,..., k מתקיים (v i, v i+1 E וגם מתקיים.(v 1 v 2... v k v 1 סימון המעגל יתבצע כך:.(v k, v 1 E בהינתן גרף, נרצה לדעת אם מתקיים בו מעגל. טענה 11.8 בגרף נתון לא קיים מעגל (כלומר הוא,(DAG אמ"ם הוא לא מכיל "צלעות לאחור". 41

הוכחה: נניח ש,u (v E הוא צלע לאחור. נוכיח שבהכרח קיים מעגל ב G. לכן, קיים מסלול v,... u שהוא חלק מהעץ (כלומר קיימים n צלעות עץ המחברות ביניהם, לכן קיים מעגל... v ב G. u v נניח שקיים מעגל v 1 v 2... v k v 1 ב G. נוכיח שבהכרח קיים צלע לאחור. נזכר, כי על ידי הרצת,DF S יתקבלו כל המסלולים העציים בגרף. יהי v i הקודקוד ההתחלתי ממנו נריץ,DF S לכן כל v j v i הם צאצאים של v i בעץ.DF S בפרט, גם 1 i v צאצא. לכן קיים מסלול מ v 1 אל 1 i v. נסיק אם כן, על פי הגדרת "צלע לאחור", כי i v 1 i, v הוא צלע לאחור. יישום DFS לסיווג הצלעות ניתן להשתמש בתכונות התיארוך של PREVIST :DFS ו,POSTVISIT על מנת לסווג את צלעות הגרף לסוגים השונים. כפי שתואר, סמן PREVISIT מסמן את זמן הכניסה לקודקוד, וסמן POSTVISIT מסמן את זמן היציאה ממנו. תאורית הסוגריים בהינתן שני קודקודים בגרף,u, v V וצלע,u (v E היוצאת מ u ומתחברת ל v. לאחר הרצת DF S קיימים שלושה מצבים אפשריים בקשר ליחס בין זמני הכניסה/יציאה ביניהם. ˆ לפרקי הזמן ] OST [u, P RE, u.p ו ] OST [v.p RE, v.p אין שום זמן משותף, ולכן u ו v שייכים למסלולים נפרדים. ואף אחד מהם אינו צאצא של השני. הצלע (v,u היא צלע צולבת. ˆ פרק הזמן של [u, P RE, u, P OST ] :u מוכל כולו בתוך פרק הזמן של.[v.P RE, v.p OST ] :v לכן u הוא צאצא של v. ובנוסף, הצלע (v,u היא צלע לאחור. ˆ פרק הזמן של [v.p RE, v.p OST ]:v מוכל כולו בתוך פרק הזמן של.[u, P RE, u, P OST ] :u לכן v צאצא של.u הצלע (v,u היא צלע עץ או צלע לפנים. 42

איור 2: (a תוצאת הרצת DF S על גרף מכוון. (b פרקי הזמן של כל קודקוד בגרף. ניתן לראות שאם פרק זמן של קודקוד v מוכל בתוך פרק זמן של u, אזי v הוא צאצא של (c u. הגרף מתואר כיער, עם עץ נפרד לכל שורש. מכיוון שגרף מכיל מעגל אמ"ם קיים צלע לאחור. ניתן, לאחר הרצת EXP LORE על הגרף, לעבור על כל הצלעות ולבדוק אם קיימת צלע אשר פרק הזמן של קודקוד השורש (ממנו יוצאת הצלע מוכל בתוך פרק הזמן של קודקוד המטרה (אליו מוכוונת הצלע. 11.4 מיון טופולוגי הגדרה 11.9 מיון טופולוגי עבור גרף מכוון,G הוא מיון כל הקודקודים בגרף:,v 1 v 2... v n כך שאם (v i, v j E אזי.v i v j תכונה זו טרנזיטיבית!. לא עבור כל גרף מכוון קיים מיון טופולוגי. תנאי מספיק לאי קיום מיון טופולוגי הוא כאשר קיים מעגל בגרף. טענה 11.10 לגרף מכוון המכיל מעגל אינו קיים מיון טופולוגי. 43

הוכחה: נניח ש 1 (v 1 v 2... v k v הוא מעגל בגרף.G מכיוון ש,(v k, v 1 E אזי על פי הגדרת המיון הטופולוגי, בכל מיון טופולוגי של הגרף יתקיים ש v. k v 1 אבל, ניתן להסיק מהמעגל הנתון ש,v 1 v 2... v k ומטרנזיטיביות יתקבל כי.v 1 v k סתירה. אם, לאחר בדיקה, ידוע כי הגרף הוא.DAG ניתן למיין את הקודקודים במיון טופולוגי באמצעות זמני הכניסה/יציאה. סידור על פי זמני היציאה בסדר יורד ימיין את הקודקודים כמיון טופולוגי. טענה 11.11 אם G הוא,DAG אזי סידור הקודקודים על פי זמני היציאה בסדר יורד יתבטא כמיון טופולוגי. הוכחה: יהי צלע.(u, v E ˆ אם מתודת EXP LORE ביקרה קודם ב u : אם קריאת EXP LORE על v מתבצעת מתוך הקריאה הנוכחית (מ u, אזי קריאת EXP LORE על v תסתיים לפני סיום הקריאה על u. אם קריאת EXP LORE על v מתבצעת מתוך קריאת EXP LORE על קודקוד w u (שאף קריאה זו התבצעה, רקורסיבית, מתוך הקריאה על u, אזי גם במקרה הזה, קריאת EXP LORE על v תסתיים לפני הקריאה על u. ˆ אם מתודת EXP LORE ביקרה קודם ב v, מכיוון שהגרף הוא ללא מעגלים, לא תיתכן קריאה רקורסיבית על u מתוך הקריאה על v. ולכן הקריאה על v תסתיים לפני הקריאה על u. בכל מקרה יתקבל כי (U P, OST (v < P OST ולכן על ידי סידור זמני היציאות בסדר יורד, יתקבל ש u. v 11.5 רכיבי קשירות חזקים הגדרה 11.12 רכיב קשירות חזק בגרף מכוון הוא תת קבוצה של קודקודים C, V כאשר לכל,u v C קיים מסלול ביניהם. כלומר קיים מסלול מ uל v, וגם קיים מסלול מ v ל u, עבור כל,u v C (בגרף לא מכוון מספיק שיהיה קיים מסלול מסוים ביניהם, כי כל מסלול לא מכוון הוא דו כיווני. על מנת למצוא רכיבי קשירות חזקים בגרף לא מכוון ניתן לבצע DF S עם שינוי קל, ספירת הפעמים שמאתחלים את האלגוריתם על קודקוד חדש והצבת הערך המונה בכל קודקוד של קריאה נוכחית (בגרף לא מכוון, כל קריאה מחודשת של DF S משמעה שלא קיים אף צלע המחברת אותו לאף קודקוד שכבר עברנו עליו. DFS_CC(G// f o r non d i r e c t e d graph f o r each v in V v. v i s i t e d = 0 ; cc =0;// connected component counter f o r each v in V i f v. v i s i t e d == 0 cc++; EXPLORE(G, v, cc 44